Effects of Serial Programs in Multiprocessing Systems

A model of a multiprocessing, multiprogramming computer system with serially reusable programs was developed to study the effect of serial programs on system performance. Two strategies for implementing serially reusable programs were investigated, a wait strategy in which the processor waits until the serial program is available, and a switch strategy, in which the processor is freed to do other work. Relative performances and asymptotic conditions as functions of the number of processors, processes, serially reusable programs, and the fraction of time each process executes serially reusable programs were obtained. Quantitative results are presented showing that the switch strategy is superior. The wait strategy causes quick saturation when the number of processes is increased. Introduction In any multiprocessing, multiprogramming system [ 11 there are parts of the operating system code which cannot be executed concurrently by more than one processor, e.g., the mechanism that assigns processors to tasks and the mechanism that assigns page frames to tasks. This paper studies the effect of these serially reusable sections of code on the performance of multiprocessor systems. To maximize the amount of concurrency possible within the operating system, the entire system can be partitioned into a collection of component programs. Each portion of the system which must be executed serially is made a separate program. We denote these as serial programs (SP). The paging algorithm and the dispatcher or scheduler are examples of serial programs found in typical multiprocessor operating systems. Programs that can be executed concurrently by more than one processor are denoted as concurrent programs (CP). Two fundamentally different strategies are available to enforce the serial execution (one processor at a time) of the serial programs. First, we assume that a lock or semaphore is associated with each serial program. 1. A process [ 21 attempting to execute an SP will test the lock. If the lock is not set, then the process will set it, execute the SP, and finally reset the lock. If the lock was set, the process and its associated processor will wait for the lock to be reset. Because the processor waits with the process, this strategy is called the wait strategy. 2. Same as 1 except that if the lock was set, the process waits for the lock but the processor is freed to do other available work. Since the processor is switched upon encountering a set lock, this strategy is called the switch strategy. It is clear that in the wait strategy, the time a process is waiting for an SP is wasted time for the associated processor. With the switch strategy, this wasted time can be avoided by switching the processor to another process, if there is another process that is ready to continue. The extent to which the switch strategy is superior (in terms of throughput) to the wait strategy depends on the availability of ready processes and the overhead in switching processors among processes. The availability of ready processes depends on the level of multiprogramming and the characteristics of the processes, e.g., frequency of 1 / 0 operations and mean time between page faults. The process-switching overhead is very much machine dependent, and we assume an idealized switch strategy in which switching can be accomplished in zero time. This is taken into account when we compare the performance of the two strategies. In the remainder of this paper we investigate and compare the throughput of systems using either the wait or the switch strategy. A simplified model of multiprocessing, multiprogramming systems is developed and analyzed using standard Markov analysis techniques. Parameters of the model include the number of processors, the number of SP’s, the level of multiprogramming, and the JULY 1974 SERIAL PROGRAA SMITH Serial programs n Stage 2